#pragma once

#include "../../include/TopoDS/OMIT_MeshTraits.h"

#include <vector>
#include <set>
#include <type_traits>
#include <cassert>

namespace OMIT_NAMESPACE
{
    template <typename TV, typename TE, typename TF, typename TH> struct MeshTraits;

	template<typename Traits> class TVert;                              // 顶点类型
	template<typename Traits> class TEdge;                              // 边类型
	template<typename Traits> class TFace;                              // 面（二维单元）类型
	template<typename Traits> class TMesh_H;                            // 半边类型（不对外）
	template<typename Traits> class TMesh;                              // 网格类型
    
	template<bool PtrConst, typename Traits> class H_NextView;          // 半边的后继范围（范围 ranges）
	template<bool PtrConst, typename Traits> class H_RotaView;          // 半边的旋转后继范围

	template<bool PtrConst, typename Traits> class V_EdgeView;          // 与顶点邻接的边的范围
	template<bool PtrConst, typename Traits> class V_VertView;          // 与顶点邻接的顶点的范围

	template <typename TE, typename TF, typename TH> class DefaultV;    // 使用自定义类型 V 定义网格，类型 V
	template <typename TV, typename TF, typename TH> class DefaultE;    // 使用自定义类型 E 定义网格，类型 E
	template <typename TV, typename TE, typename TH> class DefaultF;    // 使用自定义类型 F 定义网格，类型 F
	template <typename TV, typename TE, typename TF> class DefaultH;    // 使用自定义类型 H 定义网格，类型 H

	template <typename TF, typename TH> class DefaultVE_V;              // 使用自定义类型 V 和 E 定义网格，类型 V
	template <typename TF, typename TH> class DefaultVE_E;              // 使用自定义类型 V 和 E 定义网格，类型 E

	template <typename TE, typename TH> class DefaultVF_V;              // 使用自定义类型 V 和 F 定义网格，类型 V
	template <typename TE, typename TH> class DefaultVF_F;              // 使用自定义类型 V 和 F 定义网格，类型 F

	template <typename TE, typename TF> class DefaultVH_V;              // 使用自定义类型 V 和 H 定义网格，类型 V
	template <typename TE, typename TF> class DefaultVH_H;              // 使用自定义类型 V 和 H 定义网格，类型 H

	template <typename TV, typename TH> class DefaultEF_E;              // 使用自定义类型 E 和 E 定义网格，类型 E
	template <typename TV, typename TH> class DefaultEF_F;              // 使用自定义类型 E 和 F 定义网格，类型 F

	template <typename TV, typename TF> class DefaultEH_E;              // 使用自定义类型 E 和 H 定义网格，类型 E
	template <typename TV, typename TF> class DefaultEH_H;              // 使用自定义类型 E 和 H 定义网格，类型 H

	template <typename TV, typename TE> class DefaultFH_F;              // 使用自定义类型 F 和 F 定义网格，类型 F
	template <typename TV, typename TE> class DefaultFH_H;              // 使用自定义类型 F 和 H 定义网格，类型 H

	template <typename TH> class DefaultVEF_V;                          // 使用自定义类型 V、E 和 F 定义网格，类型 V
	template <typename TH> class DefaultVEF_E;                          // 使用自定义类型 V、E 和 F 定义网格，类型 E
	template <typename TH> class DefaultVEF_F;                          // 使用自定义类型 V、E 和 F 定义网格，类型 F

	template <typename TF> class DefaultVEH_V;                          // 使用自定义类型 V、E 和 H 定义网格，类型 V
	template <typename TF> class DefaultVEH_E;                          // 使用自定义类型 V、E 和 H 定义网格，类型 E
	template <typename TF> class DefaultVEH_H;                          // 使用自定义类型 V、E 和 H 定义网格，类型 H

	template <typename TE> class DefaultVFH_V;                          // 使用自定义类型 V、F 和 H 定义网格，类型 V
	template <typename TE> class DefaultVFH_F;                          // 使用自定义类型 V、F 和 H 定义网格，类型 F
	template <typename TE> class DefaultVFH_H;                          // 使用自定义类型 V、F 和 H 定义网格，类型 H

	template <typename TV> class DefaultEFH_E;                          // 使用自定义类型 E、F 和 H 定义网格，类型 E
	template <typename TV> class DefaultEFH_F;                          // 使用自定义类型 E、F 和 H 定义网格，类型 F
	template <typename TV> class DefaultEFH_H;                          // 使用自定义类型 E、F 和 H 定义网格，类型 H

	class DefaultVEFH_V;                                                // 使用自定义类型 V、E、F 和 H 定义网格，类型 V
	class DefaultVEFH_E;                                                // 使用自定义类型 V、E、F 和 H 定义网格，类型 E
	class DefaultVEFH_F;                                                // 使用自定义类型 V、E、F 和 H 定义网格，类型 F
	class DefaultVEFH_H;                                                // 使用自定义类型 V、E、F 和 H 定义网格，类型 H
}